Managing updates to an application can be a difficult task that is prone to many errors. One reason for these errors relates to how application software and application generated data are intermingled in storage. For example, when an application is installed and initially configured, a root directory for the application is generated in a file system. The root directory includes the software (i.e., executables) and application generated data stored together throughout the root directory and, for example, in various subdirectories. In some instances, the application generated data and the software may even be intermingled within a single file.
Updating the application is complicated by this intermingling of software and data since separating the data from the software is generally difficult and, thus, the update process may erroneously over-write the data or fail to copy portions of the data. For example, patching the application may occur using two different approaches. The first approach is referred to as out-of-place patching. Out-of-place patching generally includes installing a new copy of the application with the patch in a different location (e.g., different directory) than an existing version of the application. Patching the new copy of the application avoids difficulties with erroneously overwriting data during the patching process and/or difficulties with patching corrupted software. However, the data then needs to be copied from the original installation location to the new copy to maintain continuity in the operation of the application. As mentioned previously, differentiating the data from the software is difficult and can lead to missing data and/or misplaced data when attempting to copy the data to the new location.
The second approach is referred to as in-place patching. In-place patching entails installing a patch over existing portions of the software. While this approach maintains the same root directory, difficulties may occur relating to accidentally overwriting data because of the close intermingling of the software and the data while also potentially corrupting existing software. Additionally, rolling back the patch may also present similar difficulties when using in-place patching because of the intermingling of software with the data, and the previous version of the software being modified or overwritten during the installation. Accordingly, both forms of patching present difficulties that complicate managing software updates.